home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / video / xevil-1.000 / xevil-1 / actual.C next >
C/C++ Source or Header  |  1995-08-13  |  45KB  |  2,582 lines
  1. // "actual.C"
  2. // Actual objects to be instantiated.
  3.  
  4. /*    Copyright (C) 1994  Steve Hardt
  5.  
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 1, or (at your option)
  9.     any later version.
  10.  
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  
  20.     Steve Hardt 
  21.     hardts@athena.mit.edu hardts@media.mit.edu
  22.     hardts@r4002.3dem.bioch.bcm.tmc.edu
  23.     2043 McClendon
  24.     Houston, TX 77030
  25. */
  26.  
  27. #ifndef NO_PRAGMAS
  28. #pragma implementation "actual.h"
  29. #endif
  30.  
  31.  
  32. // Include Files
  33. #include <strstream.h>
  34.  
  35. #include "utils.h"
  36. #include "coord.h"
  37. #include "world.h"
  38. #include "physical.h"
  39. #include "actual.h"
  40.  
  41. // Bitmap files.  Also contain constants and some simple methods.
  42. #include "bitmaps/explosion/explosion.bitmaps"
  43. #include "bitmaps/fire/fire.bitmaps"
  44. #include "bitmaps/n_protection/n_protection.bitmaps"
  45. #include "bitmaps/t_protection/t_protection.bitmaps"
  46.  
  47. #include "bitmaps/shell/shell.bitmaps"
  48. #include "bitmaps/swap_shell/swap_shell.bitmaps"
  49. #include "bitmaps/lance/lance.bitmaps"
  50. #include "bitmaps/frog_shell/frog_shell.bitmaps"
  51. #include "bitmaps/fireball/fireball.bitmaps"
  52. #include "bitmaps/missile/missile.bitmaps"
  53. #include "bitmaps/star/star.bitmaps"
  54.  
  55. #include "bitmaps/trapdoor/trapdoor.bitmaps"
  56. #include "bitmaps/home/home.bitmaps"
  57. #include "bitmaps/grenade/grenade.bitmaps"
  58. #include "bitmaps/xit/xit.bitmaps"
  59. #include "bitmaps/flag/flag.bitmaps"
  60.  
  61. #include "bitmaps/rock/rock.bitmaps"
  62. #include "bitmaps/weight/weight.bitmaps"
  63. #include "bitmaps/altar_of_sin/altar_of_sin.bitmaps"
  64. #include "bitmaps/doppel/doppel.bitmaps"
  65. #include "bitmaps/transmogifier/transmogifier.bitmaps"
  66. #include "bitmaps/med_kit/med_kit.bitmaps"
  67. #include "bitmaps/n_shield/n_shield.bitmaps"
  68. #include "bitmaps/t_shield/t_shield.bitmaps"
  69. #include "bitmaps/bomb/bomb.bitmaps"
  70.  
  71. #include "bitmaps/chainsaw/chainsaw.bitmaps"
  72. #include "bitmaps/pistol/pistol.bitmaps"
  73. #include "bitmaps/m_gun/m_gun.bitmaps"
  74. #include "bitmaps/lancer/lancer.bitmaps"
  75. #include "bitmaps/f_thrower/f_thrower.bitmaps"
  76. #include "bitmaps/launcher/launcher.bitmaps"
  77. #include "bitmaps/grenades/grenades.bitmaps"
  78. #include "bitmaps/shotgun/shotgun.bitmaps"
  79. #include "bitmaps/stars/stars.bitmaps"
  80. #include "bitmaps/swapper/swapper.bitmaps"
  81. #include "bitmaps/frog_gun/frog_gun.bitmaps"
  82.  
  83. #include "bitmaps/enforcer/enforcer.bitmaps"
  84. #include "bitmaps/frog/frog.bitmaps"
  85. #include "bitmaps/hero/hero.bitmaps"
  86. #include "bitmaps/ninja/ninja.bitmaps"
  87. #include "bitmaps/alien/alien.bitmaps"
  88. #include "bitmaps/chopper_boy/chopper_boy.bitmaps"
  89. #include "bitmaps/lemming/lemming.bitmaps"
  90. #include "bitmaps/fire_demon/fire_demon.bitmaps"
  91.  
  92.  
  93.  
  94. Explosion::Explosion(WorldP w,LocatorP l,const Pos &mid,
  95.              const Id &bomb_er,int r,int dMax)
  96.      : Physical(context,w,l) 
  97. { 
  98.   bomber = bomb_er;
  99.   Pos pos;
  100.   pos.x = mid.x - EXPLOSION_VISIBLE_RADIUS;
  101.   pos.y = mid.y - EXPLOSION_VISIBLE_RADIUS;
  102.  
  103.   Size size;
  104.   size.width = size.height = 2 * EXPLOSION_VISIBLE_RADIUS;
  105.  
  106.   Area narea(AR_RECT,pos,size);
  107.   area = narea;
  108.   middle = mid;
  109.   radius = r;
  110.   damageMax = dMax;
  111. }
  112.  
  113.  
  114.  
  115. Boolean Explosion::collidable()
  116. {
  117.   return False;
  118. }
  119.  
  120.  
  121.  
  122. const Area &Explosion::get_area()
  123. {
  124.   return area;
  125. }
  126.  
  127.  
  128.  
  129. const Area &Explosion::get_area_next()
  130. {
  131.   return area;
  132. }
  133.  
  134.  
  135.  
  136. void Explosion::draw(Drawable buffer,Xvars &xvars,int dpyNum,
  137.              const Area &bufArea)
  138. {
  139.   Pos pos;
  140.   Size size;
  141.   area.get_rect(pos,size);
  142.   Size offset = area - bufArea;
  143.  
  144.   XFillArc(xvars.dpy[dpyNum],buffer,xvars.gc[dpyNum],
  145.        offset.width,offset.height,
  146.        size.width,size.height,
  147.        0,23040);
  148. /*  XFillRectangle(xvars.dpy,buffer,xvars.gc,
  149.          offset.width,offset.height,
  150.          size.width,size.height); */
  151. }
  152.  
  153.  
  154.  
  155. void Explosion::act() 
  156. {
  157.   PhysicalP nearby[OL_NEARBY_MAX];
  158.   int nitems;
  159.   LocatorP locator = get_locator();
  160.   locator->get_nearby(nearby,nitems,this,radius);
  161.   
  162.   PhysicalP p = locator->lookup(bomber);
  163.   int hit = 0;
  164.   
  165.   for (int n = 0; n < nitems; n++)
  166.     if (nearby[n]->collidable())
  167.       { 
  168.     const Area &otherArea = nearby[n]->get_area();
  169.     int distance = middle.distance(otherArea.get_middle());
  170.     assert (distance >= 0);
  171.     nearby[n]->corporeal_attack(p,damageMax*(radius-distance)/radius);
  172.     hit++;
  173.       }
  174.  
  175.   ostrstream msg;
  176.   msg << "Explosion hits " << hit << " objects." << ends;
  177.   locator->message_enq(msg.str());
  178.  
  179.   kill_self();
  180.   Physical::act();
  181. }
  182.  
  183.  
  184.  
  185. Fire::Fire(WorldP w,LocatorP l,const Pos &mid,Boolean coll)
  186. : Physical(context,w,l)
  187. {
  188.   Pos pos;
  189.   pos.x = mid.x - FIRE_DIAMETER_INIT / 2;
  190.   pos.y = mid.y - FIRE_DIAMETER_INIT / 2;
  191.   Size size;
  192.   size.width = size.height = FIRE_DIAMETER_INIT;
  193.  
  194.   Area nArea(AR_RECT,pos,size);
  195.   area = areaNext = nArea;
  196.   isCollidable = coll;
  197. }
  198.  
  199.  
  200.  
  201. int Fire::get_damage() 
  202. {
  203.   return FIRE_DAMAGE;
  204. }
  205.  
  206.  
  207.  
  208. const Area &Fire::get_area()
  209. {
  210.   return area;
  211. }
  212.  
  213.  
  214.  
  215. const Area &Fire::get_area_next()
  216. {
  217.   return areaNext;
  218. }
  219.  
  220.  
  221.  
  222. Boolean Fire::collidable()
  223. {
  224.   return isCollidable;
  225. }
  226.  
  227.  
  228.  
  229. void Fire::draw(Drawable buffer,Xvars &xvars,int dpyNum,const Area &bufArea)
  230. {
  231.   const Area &area = get_area();
  232.   Pos pos;
  233.   Size size;
  234.   area.get_rect(pos,size);
  235.   Size offset = area - bufArea;
  236.  
  237.   XSetForeground(xvars.dpy[dpyNum],xvars.gc[dpyNum],xvars.red[dpyNum]);
  238.   XFillArc(xvars.dpy[dpyNum],buffer,xvars.gc[dpyNum],
  239.        offset.width,offset.height,
  240.        size.width,size.height,
  241.        0,23040);
  242.   XSetForeground(xvars.dpy[dpyNum],xvars.gc[dpyNum],xvars.black[dpyNum]);
  243. }
  244.  
  245.  
  246.  
  247. void Fire::avoid(PhysicalP)
  248. {}
  249.  
  250.  
  251.  
  252. void Fire::collide(PhysicalP other)
  253. {
  254.   if (other->is_shot())
  255.     return;
  256.   other->heat_attack(NULL,FIRE_HEAT,True);
  257. }
  258.  
  259.  
  260.  
  261. void Fire::corporeal_attack(PhysicalP,int)
  262. {}
  263.  
  264.  
  265.  
  266. void Fire::heat_attack(PhysicalP,int,Boolean)
  267. {}
  268.  
  269.  
  270.  
  271. void Fire::act()
  272. {
  273.   Pos pos;
  274.   Size size;
  275.   area.get_rect(pos,size);
  276.   
  277.   size.width -= (FIRE_RADIUS_DELTA * 2);
  278.   size.height = size.width;
  279.   if (size.width <= 0)
  280.     kill_self();
  281.   else
  282.     {
  283.       pos.x += FIRE_RADIUS_DELTA;
  284.       pos.y += FIRE_VEL_Y;
  285.       Area nArea(AR_RECT,pos,size);
  286.       areaNext = nArea;
  287.     }
  288.   Physical::act();
  289. }
  290.  
  291.  
  292.  
  293. void Fire::update()
  294. {
  295.   area = areaNext;
  296.   Physical::update();
  297. }
  298.  
  299.  
  300.  
  301. NProtection::NProtection(WorldP w,LocatorP l,const Area &area)
  302.   : Protection(context,xdata,w,l,area)
  303. {
  304.   n = N_PROTECTION_N;
  305. }
  306.  
  307.  
  308.  
  309. Boolean NProtection::corporeal_protect(int)
  310. {
  311.   assert(n >= 0);
  312.   if (n == 0)
  313.     return False;
  314.   n--;
  315.   if (n == 0 )
  316.     kill_self();
  317.   return True;
  318. }
  319.  
  320.  
  321.  
  322. Boolean NProtection::heat_protect(int,Boolean)
  323. {
  324.   assert(n >= 0);
  325.   return False;
  326. }
  327.  
  328.  
  329.  
  330. TProtection::TProtection(WorldP w,LocatorP l,const Area &area)
  331.   : Protection(context,xdata,w,l,area)
  332. {
  333.   timer.set(T_PROTECTION_TIME);
  334. }
  335.  
  336.  
  337.  
  338. void TProtection::act()
  339. {
  340.   if (timer.ready())
  341.     kill_self();
  342.   timer.clock();
  343.  
  344.   Protection::act();
  345. }
  346.  
  347.  
  348.  
  349. Boolean TProtection::corporeal_protect(int)
  350. {
  351.   return True;
  352. }
  353.  
  354.  
  355.  
  356. Boolean TProtection::heat_protect(int,Boolean)
  357. {
  358.   return True;
  359. }
  360.  
  361.  
  362.  
  363. Rock::Rock(WorldP w,LocatorP l,const Pos &pos) 
  364.      : Heavy(context,xdata,w,l,pos) 
  365. {}
  366.  
  367.  
  368.  
  369. Weight::Weight(WorldP w,LocatorP l,const Pos &pos) 
  370.      : Heavy(context,xdata,w,l,pos) 
  371. {}
  372.  
  373.  
  374.  
  375. AltarOfSin::AltarOfSin(WorldP w,LocatorP l,const Pos &pos)
  376.      : Heavy(context,xdata,w,l,pos)  
  377. {
  378.   turnTaken = False;
  379. }
  380.  
  381.  
  382.  
  383. void AltarOfSin::corporeal_attack(PhysicalP other,int)
  384. {
  385.   /* Don't fuck with the Altar of Sin. */
  386.  
  387.   if (!turnTaken)
  388.     {
  389.       IntelP intel;
  390.       if (other && (other->get_class_id() != A_AltarOfSin) &&
  391.       (intel = other->get_intel()))
  392.     {
  393.       LocatorP locator = get_locator();
  394.       ostrstream str;
  395.       
  396.       if (Utils::coinFlip() && other->is_moving())  
  397.         /* Turned into a frog. */
  398.         { 
  399.           str << intel->get_name() << " attacks the Altar of Sin and is "
  400.         << "turned into a frog." << ends;
  401.           locator->message_enq(str.str());
  402.           
  403.           other->set_intel(NULL);
  404.           if (!other->get_mapped())
  405.         cerr << "Warning:AltarOfSin::corporeal_attack: object "
  406.           << "should be mapped." << endl;
  407.           other->set_mapped_next(False);
  408.           
  409.           const Area &area = other->get_area();
  410.           Pos pos = area.get_middle() - 0.5 * Frog::get_size_max();
  411.           
  412.           PhysicalP frog = new Frog(get_world(),locator,pos,other->get_id());
  413.           assert(frog);
  414.           frog->set_intel(intel);
  415.           locator->add(frog);
  416.         }
  417.       else
  418.         /* Lose all health. */
  419.         {
  420.           str << "BLASPHMER!  " << intel->get_name() << 
  421.         " loses health for daring to attack the Altar of Sin." << ends;
  422.           locator->message_enq(str.str());
  423.           
  424.           int damage = other->get_health();
  425.           other->corporeal_attack(this,damage);
  426.         }
  427.     }
  428.       turnTaken = True;
  429.     }
  430. }
  431.  
  432.  
  433.  
  434. void AltarOfSin::heat_attack(PhysicalP,int,Boolean)
  435. {}
  436.  
  437.  
  438.  
  439. void AltarOfSin::collide(PhysicalP other)
  440. {
  441.   IntelP intel;
  442.   if ((intel = other->get_intel()) && intel->is_human() && !turnTaken)
  443.     {
  444.       int lives = intel->get_lives();
  445.       LocatorP locator = get_locator();
  446.       ostrstream msg;
  447.  
  448.       // If human has infinite lives, give him some points(kills) instead.
  449.       if (lives == IT_INFINITE_LIVES)
  450.     {
  451.       for (int n = 0; n < ALTAR_OF_SIN_KILLS; n++)
  452.         intel->add_human_kill();
  453.       
  454.       msg << intel->get_name() << " sells soul for " 
  455.         << ALTAR_OF_SIN_KILLS << " kills." << ends;
  456.     }
  457.       else
  458.     {
  459.       intel->set_lives(lives + 1);
  460.       msg << intel->get_name() << " sells soul for an extra life." << ends;
  461.     }
  462.  
  463.       locator->message_enq(msg.str());
  464.       kill_self();
  465.       turnTaken = True;
  466.     }
  467.   else
  468.     Heavy::collide(other);
  469. }
  470.  
  471.  
  472.  
  473. void AltarOfSin::update()
  474. {
  475.   turnTaken = False;
  476.   Heavy::update();
  477. }
  478.  
  479.  
  480.  
  481. Doppel::Doppel(WorldP w,LocatorP l,const Pos &pos)
  482. : Item(context,xdata,w,l,pos)
  483. {}
  484.  
  485.  
  486.  
  487. void Doppel::use(PhysicalP p)
  488. {
  489.   assert(p && p->get_intel());
  490.   stats.add_use();
  491.   WorldP world = get_world();
  492.   LocatorP locator = get_locator();
  493.   
  494.   PhysicalP obj = create_physical(p->get_area(),p->get_class_id());
  495.  
  496.   IntelOptions ops;
  497.   ops.psychotic = True;
  498.   ops.classFriends = False;
  499.   ops.ignoreItems = True;
  500.   ops.ignoreLemmings = True;
  501.   NeutralP neutral = 
  502.     new Neutral(world,locator,"Slave",&ops,
  503.         ITpsychotic|ITclassFriends|ITignoreItems|ITignoreLemmings,
  504.         p->get_intel());
  505.   assert(neutral);
  506.   locator->register_neutral(neutral);
  507.  
  508.   locator->add(obj);
  509.   obj->set_intel(neutral);
  510. //  obj->set_dont_collide(p);
  511.   
  512.   kill_self();
  513.   Item::use(p);
  514. }
  515.  
  516.  
  517.  
  518. PhysicalP Doppel::create_physical(const Area &area,ClassId classId)
  519. {
  520.   WorldP world = get_world();
  521.   LocatorP locator = get_locator();
  522.   PhysicalP obj;
  523.   Pos middle = area.get_middle();
  524.   
  525.   switch (classId)
  526.     {
  527.     case A_Ninja:
  528.       obj = new Ninja(world,locator,middle - 0.5 * Ninja::get_size_max());
  529.       break;
  530.     case A_Hero:
  531.       obj = new Hero(world,locator,middle - 0.5 * Hero::get_size_max());
  532.       break;
  533.     case A_ChopperBoy:
  534.       obj = new ChopperBoy(world,locator,
  535.                middle - 0.5 * ChopperBoy::get_size_max());
  536.       break;
  537.     case A_Alien:
  538.       obj = new Alien(world,locator,middle - 0.5 * Alien::get_size_max());
  539.       break;
  540.     default:
  541.       // choose randomly
  542.       switch (Utils::choose(4)) {
  543.       case 0: return create_physical(area,A_Ninja);
  544.       case 1: return create_physical(area,A_Hero);
  545.       case 2: return create_physical(area,A_ChopperBoy);
  546.       case 3: return create_physical(area,A_Alien);
  547.       };
  548.     };
  549.  
  550.   assert(obj);
  551.   return obj;
  552. }
  553.  
  554.  
  555.  
  556. Stats Doppel::stats;
  557.  
  558.  
  559.  
  560. Transmogifier::Transmogifier(WorldP w,LocatorP l,const Pos &pos)
  561. : AutoUse(context,xdata,w,l,pos)
  562. {}
  563.  
  564.  
  565.  
  566. void Transmogifier::use(PhysicalP other)
  567. {
  568.   assert(other->alive());
  569.   stats.add_use();
  570.  
  571.   IntelP intel = other->get_intel();
  572.  
  573.   // Must check that other does not have protection against swapping.
  574.   if (intel && !other->swap_protect())
  575.     {
  576.       LocatorP locator = get_locator();
  577.       const Area &area = other->get_area();
  578.       PhysicalP p = new_physical(area.get_middle());
  579.       locator->add(p);
  580.  
  581.       p->set_intel(intel);
  582.       other->set_intel(NULL);
  583.       other->set_quiet_death();
  584.       other->kill_self();
  585.     }
  586.   kill_self();
  587.   AutoUse::use(other);
  588. }
  589.  
  590.  
  591.  
  592. PhysicalP Transmogifier::new_physical(const Pos &middle)
  593. {
  594.   PhysicalP obj;
  595.   LocatorP locator = get_locator();
  596.   WorldP world = get_world();
  597.   
  598.   // Either a Frog, Hero, Ninja, ChopperBoy, or Alien.
  599.   switch (Utils::choose(5)) {
  600.   case 0:
  601.     {
  602.       Id invalid;
  603.       Pos pos = middle - 0.5 * Frog::get_size_max();
  604.       obj = new Frog(world,locator,pos,invalid);
  605.     }
  606.     break;
  607.   case 1:
  608.     {
  609.       Pos pos = middle - 0.5 * Hero::get_size_max();
  610.       obj = new Hero(world,locator,pos);
  611.     }
  612.     break;
  613.   case 2:
  614.     {
  615.       Pos pos = middle - 0.5 * Ninja::get_size_max();
  616.       obj = new Ninja(world,locator,pos);
  617.     }
  618.     break;
  619.   case 3:
  620.     {
  621.       Pos pos = middle - 0.5 * ChopperBoy::get_size_max();
  622.       obj = new ChopperBoy(world,locator,pos);
  623.     }
  624.     break;
  625.   case 4:
  626.     {
  627.       Pos pos = middle - 0.5 * Alien::get_size_max();
  628.       obj = new Alien(world,locator,pos);
  629.     }
  630.     break;
  631.   default:
  632.     assert(0);
  633.   };
  634.  
  635.   assert(obj);
  636.   return obj;
  637. }
  638.  
  639.  
  640.  
  641. Stats Transmogifier::stats;
  642.  
  643.  
  644.  
  645. MedKit::MedKit(WorldP w,LocatorP l,const Pos &pos) 
  646.      : AutoUse(context,xdata,w,l,pos) 
  647. {}
  648.  
  649.  
  650.  
  651. void MedKit::use(PhysicalP p)
  652. {
  653.   stats.add_use();
  654.   assert(p->alive());
  655.   p->heal();
  656.   kill_self();
  657.   AutoUse::use(p);
  658. }
  659.  
  660.  
  661.  
  662. Stats MedKit::stats;
  663.  
  664.  
  665.  
  666. NShield::NShield(WorldP w,LocatorP l,const Pos &pos) 
  667.      : Shield(context,xdata,w,l,pos) 
  668. {}
  669.  
  670.  
  671.  
  672. ProtectionP NShield::create_protection(const Area &area)
  673. {
  674.   ProtectionP pr = new NProtection(get_world(),get_locator(),area);
  675.   assert(pr);
  676.   return pr;
  677. }
  678.  
  679.  
  680.  
  681. TShield::TShield(WorldP w,LocatorP l,const Pos &pos) 
  682.      : Shield(context,xdata,w,l,pos) 
  683. {}
  684.  
  685.  
  686.  
  687. ProtectionP TShield::create_protection(const Area &area)
  688. {
  689.   ProtectionP pr = new TProtection(get_world(),get_locator(),area);
  690.   assert(pr);
  691.   return pr;
  692. }
  693.  
  694.  
  695.  
  696. Bomb::Bomb(WorldP w,LocatorP l,const Pos &p) :
  697.        Animated(context,xdata,w,l,p) 
  698. {
  699.   set_frame(BOMB_FRAME_INACTIVE);
  700.   set_frame_next(BOMB_FRAME_INACTIVE);
  701.   frame = BOMB_FRAME_INACTIVE;
  702.  
  703.   Timer ntimer(BOMB_TIME); 
  704.   timer = ntimer;
  705.   active = False;
  706.   defused = False;
  707. }
  708.  
  709.  
  710.  
  711. Boolean Bomb::is_bomb()
  712. {
  713.   return True;
  714. }
  715.  
  716.  
  717.  
  718. void Bomb::use(PhysicalP bomberP)
  719. {
  720.   if (!active) 
  721.     {
  722.       frame = BOMB_FRAME_ACTIVE;
  723.       timer.set();
  724.       active = True;
  725.       if (bomberP)
  726.     bomber = bomberP->get_id();
  727.       LocatorP locator = get_locator();
  728.       ostrstream msg;
  729.       msg << frame << ends;
  730.       locator->message_enq(msg.str());
  731.  
  732.       set_cant_take();
  733.     }
  734.   Animated::use(bomberP);
  735. }
  736.  
  737.  
  738.  
  739. void Bomb::act()
  740. {
  741.   if (active)
  742.     timer.clock();
  743.   
  744.   if (active && timer.ready())
  745.     {
  746.       if (! frame)
  747.     kill_self();
  748.       else
  749.     {
  750.       timer.set();
  751.       frame--;
  752.       
  753.       LocatorP locator = get_locator();
  754.       ostrstream msg;
  755.       msg << frame << ends;
  756.       locator->message_enq(msg.str());
  757.     }
  758.     }
  759.   
  760.   set_frame_next(frame);
  761.  
  762.  Animated::act();
  763. }
  764.  
  765.  
  766.  
  767. void Bomb::set_quiet_death()
  768. {
  769.   defused = True;
  770.   Animated::set_quiet_death();
  771. }
  772.  
  773.  
  774.  
  775. void Bomb::die()
  776. {
  777.   if (!defused)
  778.     {
  779.       stats.add_use();
  780.  
  781.       WorldP world = get_world();
  782.       LocatorP locator = get_locator();
  783.       const Area area = get_area();
  784.       
  785.       PhysicalP explosion = 
  786.     new Explosion(world,locator,area.get_middle(),bomber,
  787.               BOMB_EXPLOSION_RADIUS,BOMB_EXPLOSION_DAMAGE_MAX);
  788.       assert (explosion);
  789.       locator->add(explosion);
  790.     }  
  791.  
  792.   Animated::die();
  793. }
  794.  
  795.  
  796.  
  797. Stats Bomb::stats;
  798.  
  799.  
  800.  
  801. Shell::Shell(WorldP w,LocatorP l,const Pos &p,const Id &shooter,
  802.          Dir d) 
  803.      : Shot(context,xdata,w,l,p,shooter,d) 
  804. {}
  805.  
  806.  
  807.  
  808. SwapShell::SwapShell(WorldP w,LocatorP l,const Pos &p,
  809.              const Id &sh, const Id &sw,Dir d)
  810.      : Shot(context,xdata,w,l,p,sh,d)
  811. {
  812.   swapper = sw;
  813. }
  814.  
  815.  
  816.  
  817. void SwapShell::collide(PhysicalP other)
  818. {
  819.   if (other->is_shot())
  820.     return;
  821.  
  822.   LocatorP locator = get_locator();
  823.   const Id &shooter = get_shooter();
  824.   PhysicalP shooterP;
  825.  
  826.   // Do nothing if shooter no longer exists.
  827.   if (!other->swap_protect() && 
  828.       (shooterP = locator->lookup(shooter)))
  829.     { 
  830.       // Swap souls.
  831.       IntelP tmp = other->get_intel();
  832.       /* Don't swap unless both shooter and other have intelligence. */
  833.       if (tmp && shooterP->get_intel()) 
  834.     {
  835.       other->set_intel(shooterP->get_intel());
  836.       shooterP->set_intel(tmp);
  837.       
  838.       // Destroy swapper.
  839.       PhysicalP swapperP;
  840.       if (locator->lookup(swapperP,swapper) == OL_NO_SIG)
  841.         swapperP->kill_self();
  842.     }
  843.     }
  844.  
  845.   kill_self();
  846. }
  847.  
  848.  
  849.  
  850. Lance::Lance(WorldP w,LocatorP l,const Pos &p,const Id &shooter,Dir d)
  851.        : Shot(context,xdata,w,l,p,shooter,d,d) 
  852. {}
  853.  
  854.  
  855.  
  856. FrogShell::FrogShell(WorldP w,LocatorP l,const Pos &p,
  857.              const Id &shooter,const Id &frog_gun,Dir d) 
  858.      : Shot(context,xdata,w,l,p,shooter,d) 
  859. {
  860.   frogGun = frog_gun;
  861. }
  862.  
  863.  
  864.  
  865. void FrogShell::collide(PhysicalP other)
  866. {
  867.   // Be careful not to frog a Frog.
  868.   if (other->is_shot() || other->get_class_id() == A_Frog)
  869.     return;
  870.  
  871.   IntelP intel = other->get_intel();
  872.   if (!other->frog_protect() && intel && other->is_moving())
  873.     {
  874.       other->set_intel(NULL);
  875.       assert(other->get_mapped());
  876.       other->set_mapped_next(False);
  877.       
  878.       const Area &area = other->get_area();
  879.       Pos pos = area.get_middle() - 0.5 * Frog::get_size_max();
  880.  
  881.       LocatorP locator = get_locator();
  882.       PhysicalP frog = new Frog(get_world(),locator,pos,other->get_id());
  883.       assert(frog);
  884.       frog->set_intel(intel);
  885.       locator->add(frog);
  886.  
  887.       // Destroy frogGun.
  888.       PhysicalP p;
  889.       if (p = locator->lookup(frogGun))
  890.     p->kill_self();
  891.     }
  892.  
  893.   kill_self();
  894. }
  895.  
  896.  
  897.  
  898. Fireball::Fireball(WorldP w,LocatorP l,const Pos &p,const Id &shooter,
  899.            Dir d,int h,int t) 
  900.      : Shot(context,xdata,w,l,p,shooter,d) 
  901. {
  902.   if (t == -1)
  903.     timer.set(FIREBALL_TIME);
  904.   else
  905.     timer.set(t);
  906.  
  907.   if (h == -1)
  908.     heat = FIREBALL_HEAT;
  909.   else
  910.     heat = h;
  911. }
  912.  
  913.  
  914.  
  915. void Fireball::collide(PhysicalP other)
  916. {
  917.   // Fireballs are not destroyed by shots.
  918.   if (other->is_shot() && other->get_class_id() != A_Missile)
  919.     return;
  920.  
  921.   LocatorP locator = get_locator();
  922.   const Id &shooter = get_shooter();
  923.   PhysicalP p = locator->lookup(shooter);
  924.  
  925.   if (p)
  926.     {
  927.       // Special case.  Fireballs fired by FireDemons hurt other FireDemons.
  928.       if (p->get_class_id() == A_FireDemon && 
  929.       other->get_class_id() == A_FireDemon)
  930.     {
  931.       other->corporeal_attack(p,FIREBALL_FIRE_DEMON_DAMAGE);
  932.       kill_self();
  933.     }
  934.       else
  935.     other->heat_attack(p,heat);
  936.     }
  937.   else
  938.     other->heat_attack(NULL,heat);
  939. }
  940.  
  941.  
  942.  
  943. void Fireball::act()
  944. {
  945.   if (timer.ready())
  946.     kill_self();
  947.  
  948.   timer.clock();
  949.   Shot::act();
  950. }
  951.  
  952.  
  953.  
  954. void Fireball::draw(Drawable buffer,Xvars &xvars,int dpyNum,const Area &bufArea)
  955. {
  956.   const Area &area = get_area();
  957.   Pos pos;
  958.   Size size;
  959.   area.get_rect(pos,size);
  960.   Size offset = area - bufArea;
  961.  
  962.   XSetForeground(xvars.dpy[dpyNum],xvars.gc[dpyNum],xvars.red[dpyNum]);
  963.   XFillArc(xvars.dpy[dpyNum],buffer,xvars.gc[dpyNum],
  964.        offset.width,offset.height,
  965.        size.width,size.height,
  966.        0,23040);
  967.   XSetForeground(xvars.dpy[dpyNum],xvars.gc[dpyNum],xvars.black[dpyNum]);
  968. }
  969.  
  970.  
  971.  
  972. Missile::Missile(WorldP w,LocatorP l,const Pos &p,const Id &sh,Dir d)
  973. : Shot(context,xdata,w,l,p,sh,d,d) 
  974. {
  975.   timer.set(MISSILE_DESTRUCT_TIME);
  976.   Timer nTimer(MISSILE_ROTATE_TIME);
  977.   rotate = nTimer;
  978.   hasTarget = False;
  979.   shooterId = sh;
  980. }
  981.  
  982.  
  983.  
  984. void Missile::act()
  985. {
  986.   LocatorP locator = get_locator();
  987.  
  988.   // Find a target.
  989.   if (!hasTarget)
  990.     {
  991.       PhysicalP nearby[OL_NEARBY_MAX];
  992.       int nearbyNum;
  993.       // Should work even though this not fully constructed.
  994.       locator->get_nearby(nearby,nearbyNum,this,MISSILE_RADIUS);
  995.       
  996.       // Search through list for best possible candidate.
  997.       const Area &area = get_area();
  998.       Pos middle = area.get_middle();
  999.       int distance_2 = -1;  // Best so far.
  1000.       
  1001.       for (int n = 0; n < nearbyNum; n++)
  1002.     if (nearby[n]->alive() &&
  1003.         nearby[n]->is_creature() &&
  1004.         nearby[n]->get_id() != shooterId)
  1005.       {
  1006.         const Area &area = nearby[n]->get_area();
  1007.         int dist_2 = middle.distance_2(area.get_middle());
  1008.         
  1009.         if (distance_2 == -1 || dist_2 < distance_2)
  1010.           {
  1011.         targetId = nearby[n]->get_id();
  1012.         distance_2 = dist_2;
  1013.         hasTarget = True;
  1014.           }
  1015.       }
  1016.     }
  1017.  
  1018.   if (rotate.ready())
  1019.     {
  1020.       rotate.set();
  1021.       
  1022.       PhysicalP target;
  1023.       if (locator->lookup(target,targetId) == OL_NO_SIG)
  1024.     {
  1025.       Boolean noChange = False;
  1026.       Dir dir = get_dir();
  1027.       const Area &area = get_area();
  1028.       const Area &targetArea = target->get_area();
  1029.       Dir dirTo = area.dir_to(targetArea);
  1030.       if (dir > dirTo)
  1031.         {
  1032.           if (dir - dirTo > (CO_DIR_PURE / 2))
  1033.         dir++;
  1034.           else
  1035.         dir--;
  1036.         }
  1037.       else if (dirTo > dir)
  1038.         {
  1039.           if (dirTo - dir > (CO_DIR_PURE / 2))
  1040.         dir--;
  1041.           else
  1042.         dir++;
  1043.         }
  1044.       else 
  1045.         noChange = True;
  1046.       
  1047.       if (!noChange)
  1048.         {
  1049.           if (dir >= CO_DIR_MAX)
  1050.         dir -= CO_DIR_PURE;
  1051.           if (dir < (CO_DIR_MAX - CO_DIR_PURE))
  1052.         dir += CO_DIR_PURE;
  1053.           
  1054.           set_dir_next(dir);
  1055.           const Vel *unitVels = get_unit_vels();
  1056.           set_vel_next(context.speed * unitVels[dir]);
  1057.         }
  1058.     }
  1059.     }
  1060.   
  1061.   if (timer.ready())
  1062.     kill_self();
  1063.   
  1064.   timer.clock();
  1065.   rotate.clock();
  1066.   Shot::act();
  1067. }
  1068.  
  1069.  
  1070.  
  1071. Star::Star(WorldP w,LocatorP l,const Pos &p,const Id &sh,Dir d)
  1072. : Shot(context,xdata,w,l,p,sh,d) 
  1073. {}
  1074.  
  1075.  
  1076.  
  1077. Trapdoor::Trapdoor(WorldP w,LocatorP l,const Pos &pos,const Id &home_id)
  1078. : Moving(context,xdata,w,l,pos)
  1079. {
  1080.   Timer nTimer(TRAPDOOR_TIME);
  1081.   timer = nTimer;
  1082.   timer.set();
  1083.   
  1084.   lemmingsNum = 0;
  1085.   homeId = home_id;
  1086. }
  1087.  
  1088.  
  1089.  
  1090. Boolean Trapdoor::collidable()
  1091. {
  1092.   return False;
  1093. }
  1094.  
  1095.  
  1096.  
  1097. int Trapdoor::get_drawing_level()
  1098. {
  1099.   return 0;
  1100. }
  1101.  
  1102.  
  1103.  
  1104. void Trapdoor::act()
  1105. {
  1106.   if (timer.ready() && lemmingsNum < LEMMINGS_MAX)
  1107.     {
  1108.       LocatorP l = get_locator();
  1109.       WorldP w = get_world();
  1110.       const Area &area = get_area();
  1111.       Pos pos = area.get_middle();
  1112.       Size lemmingSize = Lemming::get_size_max();
  1113.       pos.x -= lemmingSize.width / 2;
  1114.       pos.y += lemmingSize.height;
  1115.       PhysicalP lemming = new Lemming(w,l,pos);
  1116.       assert(lemming);
  1117.  
  1118.       char lemmingStr[20];
  1119.       ostrstream str(lemmingStr,20);
  1120.       str << "lemming-" << lemmingsNum << ends;
  1121.       NeutralP lemmingIntel = new LemmingIntel(w,l,lemmingStr,homeId);
  1122.       lemming->set_intel(lemmingIntel);
  1123.       l->register_neutral(lemmingIntel);
  1124.       lemmings[lemmingsNum] = lemmingIntel->get_intel_id();
  1125.  
  1126.       l->add(lemming);
  1127.       
  1128.       lemmingsNum++;
  1129.       timer.set();
  1130.     }
  1131.  
  1132.   timer.clock();
  1133.   Moving::act();
  1134. }
  1135.  
  1136.  
  1137.  
  1138. Home::Home(WorldP w,LocatorP l,const Pos &pos)
  1139. : Moving(context,xdata,w,l,pos)
  1140. {
  1141.   lemmingsSafe = 0;
  1142. }
  1143.  
  1144.  
  1145.  
  1146. Boolean Home::collidable()
  1147. {
  1148.   return False;
  1149. }
  1150.  
  1151.  
  1152.  
  1153. int Home::get_drawing_level()
  1154. {
  1155.   return 0;
  1156. }
  1157.  
  1158.  
  1159.  
  1160. void Home::act()
  1161. {
  1162.   PhysicalP nearby[OL_NEARBY_MAX];
  1163.   int nItems;
  1164.   LocatorP locator = get_locator();
  1165.   locator->get_nearby(nearby,nItems,this,HOME_RADIUS);
  1166.  
  1167.   for (int n = 0; n < nItems; n++)
  1168.     {
  1169.       IntelP intel = nearby[n]->get_intel();
  1170.       if (intel && intel->is_lemming_intel())
  1171.     {
  1172.       nearby[n]->set_quiet_death();
  1173.       nearby[n]->kill_self();
  1174.       lemmingsSafe++;
  1175.     }
  1176.     }
  1177.   Moving::act();
  1178. }
  1179.  
  1180.  
  1181.  
  1182. Grenade::Grenade(WorldP w,LocatorP l,const Pos &pos,const Id &sh,
  1183.          Dir dir,Speed speed)
  1184. : Falling(context,xdata,w,l,pos,dir)
  1185. {
  1186.   assert(dir != CO_air);
  1187.   const Vel *unitVels = get_unit_vels();
  1188.   set_vel_next(speed * unitVels[dir]);
  1189.   
  1190.   timer.set(GRENADE_TIME);
  1191.   shooter = sh;
  1192.   defused = False;
  1193. }
  1194.  
  1195.  
  1196.  
  1197. Grenade::Grenade(WorldP w,LocatorP l,const Pos &pos,const Id &sh,
  1198.          const Vel &vel)
  1199. : Falling(context,xdata,w,l,pos,vel.get_dir())
  1200. {
  1201.   stats.add_creation();
  1202.  
  1203.   set_vel_next(vel);
  1204.   timer.set(GRENADE_TIME);
  1205.   shooter = sh;
  1206.   defused = False;
  1207. }
  1208.  
  1209.  
  1210.  
  1211. void Grenade::set_quiet_death()
  1212. {
  1213.   defused = True;
  1214.   Falling::set_quiet_death();
  1215. }
  1216.  
  1217.  
  1218.  
  1219. void Grenade::act()
  1220. {
  1221.   if (timer.ready())
  1222.     kill_self();
  1223.   
  1224.   timer.clock();
  1225.   Falling::act();
  1226. }
  1227.  
  1228.  
  1229.  
  1230. void Grenade::die()
  1231. {
  1232.   if (!defused)
  1233.     {
  1234.       WorldP world = get_world();
  1235.       LocatorP locator = get_locator();
  1236.       const Area area = get_area();
  1237.   
  1238.       PhysicalP explosion = 
  1239.     new Explosion(world,locator,area.get_middle(),shooter,
  1240.               GRENADE_EXPLOSION_RADIUS,GRENADE_EXPLOSION_DAMAGE_MAX);
  1241.       assert (explosion);
  1242.       locator->add(explosion);
  1243.     }
  1244.   Falling::die();
  1245. }
  1246.  
  1247.  
  1248.  
  1249. Stats Grenade::stats;
  1250.  
  1251.  
  1252.  
  1253. Xit::Xit(WorldP w,LocatorP l,const Pos &pos) 
  1254. : Touchable(context,xdata,w,l,pos)
  1255. {}
  1256.  
  1257.  
  1258.  
  1259. Flag::Flag(WorldP w,LocatorP l,const Pos &pos) 
  1260. : Touchable(context,xdata,w,l,pos)
  1261. {}
  1262.  
  1263.  
  1264.  
  1265. Chainsaw::Chainsaw(WorldP w,LocatorP l,const Pos &p) 
  1266. : Cutter(context,xdata,w,l,p) 
  1267. {}
  1268.  
  1269.  
  1270.  
  1271. Gun::Gun(const GunContext &g_c,
  1272.      GunXdata &x_data,
  1273.      WorldP w,
  1274.      LocatorP l,
  1275.      const Pos &p) :
  1276.        Weapon(g_c.weaponContext,x_data,w,l,p) 
  1277. {
  1278.   assert(g_c.ammoInitial <= g_c.ammoMax);
  1279.  
  1280.   gc = &g_c;
  1281.   Timer ntimer(g_c.shotTime); 
  1282.   timer = ntimer;
  1283.   ammo = g_c.ammoInitial;
  1284. }
  1285.  
  1286.  
  1287.  
  1288. Boolean Gun::is_gun()
  1289. {
  1290.   return True;
  1291. }
  1292.  
  1293.  
  1294.  
  1295. Boolean Gun::ready()
  1296. {
  1297.   return timer.ready();
  1298. }
  1299.  
  1300.  
  1301.  
  1302. int Gun::get_ammo()
  1303. {
  1304.   return ammo;
  1305. }
  1306.  
  1307.  
  1308.  
  1309. int Gun::get_ammo_max()
  1310. {
  1311.   return gc->ammoMax;
  1312. }
  1313.  
  1314.  
  1315.  
  1316. void Gun::update()
  1317. {
  1318.   timer.clock(); 
  1319.   Weapon::update();
  1320. }
  1321.  
  1322.  
  1323.  
  1324. void Gun::set_ammo(int val)
  1325. {
  1326.   assert(val <= gc->ammoMax && val >= 0);
  1327.   ammo = val;
  1328. }
  1329.  
  1330.  
  1331.  
  1332. Size Gun::get_shot_size(Dir)
  1333. {
  1334.   return Shell::get_size();
  1335. }
  1336.  
  1337.  
  1338.  
  1339. Dir Gun::compute_weapon_dir(ITcommand command)
  1340. {
  1341.   switch (command) {
  1342.   case IT_WEAPON_R:
  1343.     return CO_R;
  1344.   case IT_WEAPON_DN_R:
  1345.     return CO_DN_R;
  1346.   case IT_WEAPON_DN:
  1347.     return CO_DN;
  1348.   case IT_WEAPON_DN_L:
  1349.     return CO_DN_L;
  1350.   case IT_WEAPON_L:
  1351.     return CO_L;
  1352.   case IT_WEAPON_UP_L:
  1353.     return CO_UP_L;
  1354.   case IT_WEAPON_UP:
  1355.     return CO_UP;
  1356.   case IT_WEAPON_UP_R:
  1357.     return CO_UP_R;
  1358.   };
  1359.   return CO_air;
  1360. }
  1361.  
  1362.  
  1363.  
  1364. void Gun::fire(const Id &id,ITcommand command)
  1365. {
  1366.   Dir dir = compute_weapon_dir(command);
  1367.   _fire(id,dir);
  1368. }
  1369.  
  1370.  
  1371.  
  1372. void Gun::_fire(const Id &id,Dir dir,Boolean setTimer,Boolean costsAmmo)
  1373. /* NOTE: PH_AMMO_UNLIMITED is not currently tested. */
  1374. {
  1375.   assert((ammo == PH_AMMO_UNLIMITED) ||
  1376.      ((ammo <= gc->ammoMax) && (ammo >= 0)));
  1377.  
  1378.   // Person who fired weapon may not exist anymore. (See FThrower)
  1379.   LocatorP locator = get_locator();
  1380.   PhysicalP p;
  1381.   if (p = locator->lookup(id))
  1382.     {
  1383.       if ((dir != CO_air) && ready() && 
  1384.       ((ammo == PH_AMMO_UNLIMITED) || (ammo > 0)))
  1385.     {
  1386.       const Area &area = p->get_area();
  1387.       
  1388.       Pos newPos = area.adjacent_rect(get_shot_size(dir),dir);
  1389.       WorldP world = get_world();
  1390.       LocatorP locator = get_locator();
  1391.       
  1392.       PhysicalP shot = create_shot(p,world,locator,newPos,dir);
  1393.       shot->set_dont_collide(p);
  1394.       locator->add(shot);
  1395.       if (setTimer)
  1396.         timer.set();
  1397.       
  1398.       if (costsAmmo && ammo != PH_AMMO_UNLIMITED)
  1399.         ammo--;
  1400.     }
  1401.     }  
  1402. }
  1403.  
  1404.  
  1405.  
  1406. PhysicalP Gun::create_shot(PhysicalP shooter,WorldP world,LocatorP locator,
  1407.                const Pos &pos,Dir dir)
  1408. {
  1409.   PhysicalP shot = new Shell(world,locator,pos,shooter->get_id(),dir);
  1410.   assert (shot);
  1411.   return shot;
  1412. }
  1413.  
  1414.  
  1415.  
  1416. SingleGun::SingleGun(const SingleGunContext &c,
  1417.              SingleGunXdata &x_data,
  1418.              WorldP w,LocatorP l,const Pos &p) 
  1419.     : Gun(c.gunContext,x_data,w,l,p) 
  1420. {}
  1421.  
  1422.  
  1423.  
  1424. Boolean SingleGun::ready()
  1425. {
  1426.   // Can only fire if previous shot has been destroyed.
  1427.   PhysicalP shot;
  1428.   LocatorP locator = get_locator();
  1429.  
  1430.   return (locator->lookup(shot,shotId) == OL_NOT_FOUND) && Gun::ready();
  1431. }
  1432.  
  1433.  
  1434.  
  1435. void SingleGun::fire(const Id &id,ITcommand command)
  1436. {
  1437.   assert(get_ammo() == PH_AMMO_UNLIMITED);
  1438.  
  1439.   LocatorP locator = get_locator();
  1440.   PhysicalP p;
  1441.   if (locator->lookup(p,id) == OL_NO_SIG)
  1442.     {
  1443.       Dir dir = compute_weapon_dir(command);
  1444.       if ((dir != CO_air) && ready())
  1445.     {
  1446.       const Area &area = p->get_area();
  1447.       
  1448.       Pos newPos = area.adjacent_rect(get_shot_size(dir),dir);
  1449.       WorldP world = get_world();
  1450.       
  1451.       LocatorP locator = get_locator();
  1452.       PhysicalP shot = create_shot(p,world,locator,newPos,dir);
  1453.       shot->set_dont_collide(p);
  1454.       locator->add(shot);
  1455.       
  1456.       shotId = shot->get_id();
  1457.     }
  1458.     }
  1459. }
  1460.  
  1461.  
  1462.  
  1463. Pistol::Pistol(WorldP w,LocatorP l,const Pos &p) 
  1464.      : Gun(context,xdata,w,l,p) 
  1465. {}
  1466.  
  1467.  
  1468.  
  1469. MGun::MGun(WorldP w,LocatorP l,const Pos &p) 
  1470.      : Gun(context,xdata,w,l,p) 
  1471. {}
  1472.  
  1473.  
  1474.  
  1475. Swapper::Swapper(WorldP w,LocatorP l,const Pos &p) :
  1476.        SingleGun(context,xdata,w,l,p) 
  1477. {}
  1478.  
  1479.  
  1480.  
  1481. Size Swapper::get_shot_size(Dir)
  1482. {
  1483.   return SwapShell::get_size();
  1484. }
  1485.  
  1486.  
  1487.  
  1488. PhysicalP Swapper::create_shot(PhysicalP shooter,WorldP w,LocatorP l,
  1489.                    const Pos &pos,Dir d)
  1490. {
  1491.   PhysicalP swapShell = new SwapShell(w,l,pos,shooter->get_id(),get_id(),d);
  1492.   assert (swapShell);
  1493.   return swapShell;
  1494. }
  1495.  
  1496.  
  1497.  
  1498. Lancer::Lancer(WorldP w,LocatorP l,const Pos &p) 
  1499.      : Gun(context,xdata,w,l,p) 
  1500. {}
  1501.  
  1502.  
  1503.  
  1504. Size Lancer::get_shot_size(Dir dir)
  1505. {
  1506.   return Lance::get_size(dir);
  1507. }
  1508.  
  1509.  
  1510.  
  1511. Dir Lancer::compute_weapon_dir(ITcommand command)
  1512. {
  1513.   switch (command) {
  1514.   case IT_WEAPON_R:
  1515.     return CO_R;
  1516.   case IT_WEAPON_DN_R:
  1517.     return CO_DN_R_R;
  1518.   case IT_WEAPON_DN:
  1519.     return CO_DN;
  1520.   case IT_WEAPON_DN_L:
  1521.     return CO_DN_L_L;
  1522.   case IT_WEAPON_L:
  1523.     return CO_L;
  1524.   case IT_WEAPON_UP_L:
  1525.     return CO_UP_L_L;
  1526.   case IT_WEAPON_UP:
  1527.     return CO_UP;
  1528.   case IT_WEAPON_UP_R:
  1529.     return CO_UP_R_R;
  1530.   };
  1531.   return CO_air;
  1532. }
  1533.  
  1534.  
  1535.  
  1536. PhysicalP Lancer::create_shot(PhysicalP shooter,WorldP w,LocatorP l,
  1537.                   const Pos &pos,Dir d)
  1538. {
  1539.   PhysicalP lance = new Lance(w,l,pos,shooter->get_id(),d);
  1540.   assert (lance);
  1541.   return lance;
  1542. }
  1543.  
  1544.  
  1545.  
  1546. FrogGun::FrogGun(WorldP w,LocatorP l,const Pos &p) :
  1547.        SingleGun(context,xdata,w,l,p) 
  1548. {}
  1549.  
  1550.  
  1551.  
  1552. Size FrogGun::get_shot_size(Dir)
  1553. {
  1554.   return FrogShell::get_size();
  1555. }
  1556.  
  1557.  
  1558.  
  1559. PhysicalP FrogGun::create_shot(PhysicalP shooter,WorldP w,LocatorP l,
  1560.                    const Pos &pos,Dir d)
  1561. {
  1562.   PhysicalP shot = new FrogShell(w,l,pos,shooter->get_id(),get_id(),d);
  1563.   assert (shot);
  1564.   return shot;
  1565. }
  1566.  
  1567.  
  1568.  
  1569. FThrower::FThrower(WorldP w,LocatorP l,const Pos &p) :
  1570.        Gun(context,xdata,w,l,p) 
  1571. {
  1572.   Timer nTimer(F_THROWER_FIRE_TIME);
  1573.   stopFiring = nTimer;
  1574.   isFiring = False;
  1575. }
  1576.  
  1577.  
  1578.  
  1579. PhysicalP FThrower::create_shot(PhysicalP shooter,WorldP w,LocatorP l,
  1580.                   const Pos &pos,Dir d)
  1581. {
  1582.   PhysicalP fireball = new Fireball(w,l,pos,shooter->get_id(),d);
  1583.   assert (fireball);
  1584.   return fireball;
  1585. }
  1586.  
  1587.  
  1588.  
  1589. void FThrower::fire(const Id &id,ITcommand command)
  1590. {
  1591.   killerId = id;
  1592.   fireCommand = command;
  1593.   stopFiring.set();
  1594.   isFiring = True;
  1595. }
  1596.  
  1597.  
  1598.  
  1599. void FThrower::act()
  1600. {
  1601.   if (isFiring && stopFiring.ready())
  1602.     isFiring = False;
  1603.  
  1604.   if (isFiring)
  1605.     Gun::fire(killerId,fireCommand);
  1606.   
  1607.   stopFiring.clock();
  1608.   Gun::act();
  1609. }
  1610.  
  1611.  
  1612.  
  1613. Size FThrower::get_shot_size(Dir)
  1614. {
  1615.   return Fireball::get_size();
  1616. }
  1617.  
  1618.  
  1619.  
  1620. Launcher::Launcher(WorldP w,LocatorP l,const Pos &p) 
  1621. : Gun(context,xdata,w,l,p) 
  1622. {}
  1623.  
  1624.  
  1625.  
  1626. Size Launcher::get_shot_size(Dir dir)
  1627. {
  1628.   return Missile::get_size(dir);
  1629. }
  1630.  
  1631.  
  1632.  
  1633. PhysicalP Launcher::create_shot(PhysicalP shooter,WorldP world,
  1634.                 LocatorP locator,const Pos &pos,Dir dir)
  1635. {
  1636.   PhysicalP shot = new Missile(world,locator,pos,shooter->get_id(),dir);
  1637.   assert (shot);
  1638.   return shot;
  1639. }
  1640.  
  1641.  
  1642.  
  1643. Grenades::Grenades(WorldP w,LocatorP l,const Pos &p) 
  1644. : Gun(context,xdata,w,l,p) 
  1645. {}
  1646.  
  1647.  
  1648.  
  1649. Size Grenades::get_shot_size(Dir dir)
  1650. {
  1651.   return Grenade::get_size(dir);
  1652. }
  1653.  
  1654.  
  1655.  
  1656. PhysicalP Grenades::create_shot(PhysicalP shooter,WorldP world,
  1657.                 LocatorP locator,const Pos &pos,Dir dir)
  1658. {
  1659.   Speed speed;
  1660.   if (dir == CO_UP_L || dir == CO_UP || dir == CO_UP_R)
  1661.     speed = GRENADES_TOSS_SPEED;
  1662.   else if (dir == CO_R || dir == CO_DN_R || dir == CO_DN_L || dir == CO_L)
  1663.     speed = GRENADES_ROLL_SPEED;
  1664.   else if (dir == CO_DN)
  1665.     speed = 0;
  1666.   else
  1667.     assert(0);
  1668.  
  1669.   assert(shooter->is_moving());
  1670.   const Vel *unitVels = get_unit_vels();
  1671.   Vel vel = ((MovingP)shooter)->get_vel() + speed * unitVels[dir];
  1672.  
  1673. //  PhysicalP shot = new Grenade(world,locator,pos,shooter->get_id(),dir,speed);
  1674.   PhysicalP shot = new Grenade(world,locator,pos,shooter->get_id(),vel);
  1675.   assert (shot);
  1676.   return shot;
  1677. }
  1678.  
  1679.  
  1680.  
  1681. Shotgun::Shotgun(WorldP w,LocatorP l,const Pos &p) 
  1682.      : Gun(context,xdata,w,l,p) 
  1683. {}
  1684.  
  1685.  
  1686.  
  1687. void Shotgun::fire(const Id &id,ITcommand command)
  1688. {
  1689.   Dir dir = compute_weapon_dir(command);
  1690.   LocatorP l = get_locator();
  1691.   PhysicalP shooter;
  1692.   int ammo;
  1693.  
  1694.   if ((shooter = l->lookup(id)) && dir != CO_air && ready() && 
  1695.       (ammo = get_ammo()) > 0)
  1696.     {
  1697.       const Area &shooterArea = shooter->get_area();
  1698.       
  1699.       PhysicalP nearby[OL_NEARBY_MAX];
  1700.       int nearbyNum;
  1701.       l->get_nearby(nearby,nearbyNum,shooter,SHOTGUN_RADIUS);
  1702.       const Vel *unitVels = get_unit_vels();
  1703.  
  1704.       for (int n = 0; n < nearbyNum; n++)
  1705.     {
  1706.       Size diff = nearby[n]->get_area() - shooterArea;
  1707.  
  1708.       if (diff.get_dir() == dir)
  1709.         {
  1710.           if (nearby[n]->is_moving())
  1711.         ((MovingP)nearby[n])->
  1712.           set_extra_vel_next((SHOTGUN_SLAM_MOMENTUM / 
  1713.                       nearby[n]->get_mass()) *
  1714.                      unitVels[dir]);
  1715. //          ((MovingP)nearby[n])->set_vel_next(0);
  1716.           nearby[n]->corporeal_attack(shooter,SHOTGUN_DAMAGE);
  1717.         }
  1718.     }
  1719.  
  1720.       if (shooter->is_moving())
  1721.     ((MovingP)shooter)->
  1722.       set_extra_vel_next((SHOTGUN_RECOIL_MOMENTUM /
  1723.                   shooter->get_mass()) * 
  1724.                  unitVels[Coord::dir_opposite(dir)]);
  1725.       
  1726.       set_ammo(ammo - 1);
  1727.       set_shot_timer();
  1728.     }
  1729. }
  1730.  
  1731.  
  1732.  
  1733. Stars::Stars(WorldP w,LocatorP l,const Pos &p) 
  1734.      : Gun(context,xdata,w,l,p) 
  1735. {}
  1736.  
  1737.  
  1738.  
  1739. Size Stars::get_shot_size(Dir)
  1740. {
  1741.   return Star::get_size();
  1742. }
  1743.  
  1744.  
  1745.  
  1746. PhysicalP Stars::create_shot(PhysicalP shooter,WorldP world,LocatorP locator,
  1747.                  const Pos &pos,Dir dir)
  1748. {
  1749.   PhysicalP shot = new Star(world,locator,pos,shooter->get_id(),dir);
  1750.   assert (shot);
  1751.   return shot;
  1752. }
  1753.  
  1754.  
  1755.  
  1756. void Stars::fire(const Id &shooterId,ITcommand command)
  1757. {
  1758.   LocatorP locator = get_locator();
  1759.   PhysicalP shooter = locator->lookup(shooterId);
  1760.   if (shooter)
  1761.     {
  1762.       // Ninjas firing stars give a wider spread.
  1763.       int delta = (shooter->get_class_id() == A_Ninja) ? 2 : 1;
  1764.  
  1765.       // Fire a spread of shots around center.
  1766.       Dir center = Intel::command_weapon_to_dir_8(command);
  1767.       if (center != CO_air)
  1768.     for (Dir baseDir = center - delta; baseDir <= center + delta; baseDir++)
  1769.       {
  1770.         Dir dir;
  1771.         if (baseDir >= CO_DIR_MAX)
  1772.           dir = baseDir - CO_DIR_PURE;
  1773.         else if (baseDir < CO_DIR_MAX - CO_DIR_PURE)
  1774.           dir = baseDir + CO_DIR_PURE;
  1775.         else
  1776.           dir = baseDir;
  1777.  
  1778.         // Only set the timer on the last shot.
  1779.         Boolean lastOne = (baseDir == center + delta);
  1780.         Gun::_fire(shooterId,dir,lastOne,lastOne);
  1781.       }
  1782.     }
  1783. }
  1784.  
  1785.  
  1786.  
  1787. Enforcer::Enforcer(WorldP w,LocatorP l,const Pos &rawPos)
  1788.      : Creature(creatureContext,creatureXdata,w,l,rawPos),
  1789.        Grounded(groundedContext,groundedXdata),
  1790.        Suicide(suicideContext,suicideXdata)
  1791. {}
  1792.  
  1793.  
  1794.  
  1795. Boolean Enforcer::is_suicide()
  1796. {
  1797.   return True;
  1798. }
  1799.  
  1800.  
  1801.  
  1802. Boolean Enforcer::prickly()
  1803. {
  1804.   return True;
  1805. }
  1806.  
  1807.  
  1808.  
  1809. void Enforcer::collide(PhysicalP other)
  1810. {
  1811.   if (alive())
  1812.     other->corporeal_attack(this,ENFORCER_DAMAGE);
  1813.  
  1814.   Grounded::collide(other);
  1815. }
  1816.  
  1817.  
  1818.  
  1819. void Enforcer::act()
  1820. {
  1821.   Grounded::_act();
  1822.   Suicide::_act();
  1823.   Creature::act();
  1824. }
  1825.  
  1826.  
  1827.  
  1828. void Enforcer::die()
  1829. {
  1830.   if (!get_quiet_death())
  1831.     stats.add_death(get_birth_time());
  1832.   
  1833.   Grounded::die();
  1834. }
  1835.  
  1836.  
  1837. Stats Enforcer::stats;
  1838.  
  1839.  
  1840.  
  1841. Frog::Frog(WorldP w,LocatorP l,const Pos &rawPos,const Id &un_mapped) 
  1842.      : Creature(creatureContext,creatureXdata,w,l,rawPos),
  1843.        Hopping(hoppingContext,hoppingXdata)
  1844. {
  1845.   PhysicalP p;
  1846.   if (l->lookup(p,un_mapped) == OL_NO_SIG)
  1847.     {
  1848.       unmapped = un_mapped;
  1849.       assert (p->get_intel() == NULL);
  1850.  
  1851.       timer.set(FROG_TIME);
  1852.       unmappedSet = True;
  1853.     }
  1854.   else
  1855.     unmappedSet = False;
  1856. }
  1857.  
  1858.  
  1859.  
  1860. void Frog::act()
  1861. {
  1862.   // alive() may not be necessary.
  1863.   if (alive() && unmappedSet)
  1864.     {
  1865.       LocatorP locator = get_locator();
  1866.       PhysicalP p = locator->lookup(unmapped);
  1867.       if (p && p->alive())
  1868.     {
  1869.       assert(p->is_moving());
  1870.       const Area &area = get_area();
  1871.       ((MovingP)p)->set_middle_next(area.get_middle());
  1872.       
  1873.       if (timer.ready())
  1874.         {
  1875.           p->set_intel(get_intel());
  1876.           p->set_mapped_next(True);
  1877.           set_intel(NULL);
  1878.           set_quiet_death();
  1879.           kill_self();
  1880.           
  1881.           unmappedSet = False;
  1882.         }
  1883.     }
  1884.     }
  1885.   
  1886.   if (unmappedSet)
  1887.     timer.clock();
  1888.   Hopping::act();
  1889. }
  1890.  
  1891.  
  1892.  
  1893. void Frog::die()
  1894. {
  1895.   if (!get_quiet_death())
  1896.     stats.add_death(get_birth_time());
  1897.   
  1898.   if (unmappedSet)
  1899.     {
  1900.       LocatorP locator = get_locator();
  1901.       PhysicalP p;
  1902.       if ((p = locator->lookup(unmapped)) && p->alive())
  1903.     {
  1904.       assert(p->get_intel() == NULL);
  1905.       p->set_intel(get_intel());
  1906.       set_intel(NULL);
  1907.  
  1908.       if (get_quiet_death())
  1909.         {
  1910.           p->set_quiet_death();
  1911.         }
  1912.       else
  1913.         {
  1914.           p->set_mapped_next(True);
  1915.           const Area &area = get_area();
  1916.           assert(p->is_moving());
  1917.           ((MovingP)p)->set_middle_next(area.get_middle());
  1918.         }
  1919.  
  1920.       if (!p->die_called())
  1921.         {
  1922.           /* Partial hack to prevent corpse from getting knocked out of
  1923.          the world. */
  1924.           const Area &area = p->get_area_next();
  1925.           WorldP world = get_world();
  1926.           if (!world->inside(area.middle_wsquare()))
  1927.         p->set_quiet_death();
  1928.  
  1929.           p->kill_self();
  1930.           p->die();
  1931.         }
  1932.       
  1933.       set_quiet_death();
  1934.     }
  1935.     }
  1936.   Hopping::die();
  1937. }
  1938.  
  1939.  
  1940.  
  1941. Stats Frog::stats;
  1942.  
  1943.  
  1944.  
  1945. Hero::Hero(WorldP w,LocatorP l,const Pos &rawPos) 
  1946.      : Creature(creatureContext,creatureXdata,w,l,rawPos),
  1947.        Walking(walkingContext,walkingXdata),
  1948.        Fighter(fighterContext,fighterXdata),
  1949.        User(userContext,userXdata)
  1950. {
  1951.   healthMin = get_health();
  1952.   Timer t(HERO_HEAL_TIME);
  1953.   healTimer = t;
  1954.   healTimer.set();
  1955. }
  1956.  
  1957.  
  1958.  
  1959. Boolean Hero::is_fighter() 
  1960. {
  1961.   return True;
  1962. }
  1963.  
  1964.  
  1965.  
  1966. Boolean Hero::is_walking() 
  1967. {
  1968.   return True;
  1969. }
  1970.  
  1971.  
  1972.  
  1973. Boolean Hero::is_user() 
  1974. {
  1975.   return True;
  1976. }
  1977.  
  1978.  
  1979.  
  1980. void Hero::get_pixmap_mask(int dpyNum,Pixmap &pixmap,Pixmap &mask,Dir dir,
  1981.                int animNum)
  1982. {
  1983.   Fighter::get_pixmap_mask(dpyNum,pixmap,mask,dir,animNum);
  1984. }
  1985.  
  1986.  
  1987.  
  1988. void Hero::get_size_offset_next(Size &size,Size &offset,Dir dirNext)
  1989. {
  1990.   Fighter::get_size_offset_next(size,offset,dirNext);
  1991. }
  1992.  
  1993.  
  1994.  
  1995. int Hero::get_weapons_num()
  1996. {
  1997.   return User::get_weapons_num();
  1998. }
  1999.  
  2000.  
  2001.  
  2002. int Hero::get_items_num()
  2003. {
  2004.   return User::get_items_num();
  2005. }
  2006.  
  2007.  
  2008.  
  2009. PhysicalP Hero::get_weapon(int n)
  2010. {
  2011.   return User::get_weapon(n);
  2012. }
  2013.  
  2014.  
  2015.  
  2016. PhysicalP Hero::get_item(int n)
  2017. {
  2018.   return User::get_item(n);
  2019. }
  2020.  
  2021.  
  2022.  
  2023. PhysicalP Hero::get_weapon_current()
  2024. {
  2025.   return User::get_weapon_current();
  2026. }
  2027.  
  2028.  
  2029.  
  2030. PhysicalP Hero::get_item_current()
  2031. {
  2032.   return User::get_item_current();
  2033. }
  2034.  
  2035.  
  2036.  
  2037. void Hero::set_mapped_next(Boolean val)
  2038. {
  2039.  User::set_mapped_next(val);
  2040. }
  2041.  
  2042.  
  2043.  
  2044. void Hero::heal()
  2045. {
  2046.   // Somewhat of a hack.  Skipping a level in calling up the tree. 
  2047.   Creature::heal();
  2048.  
  2049.   healthMin = get_health_max();
  2050. }
  2051.  
  2052.  
  2053.  
  2054. void Hero::act()
  2055. {
  2056.   if (alive())
  2057.     {
  2058.       // Heal Hero up to HERO_HEAL_MULTIPLIER * min health.
  2059.       Health health = get_health();
  2060.       if (health < healthMin)
  2061.     healthMin = health;
  2062.       
  2063.       if (healTimer.ready())
  2064.     {
  2065.       Health healthBest = 
  2066.         min(get_health_max(),((int)(healthMin * HERO_HEAL_MULTIPLIER)));
  2067.       Health healthNext = health + HERO_HEAL;
  2068.       if (healthNext > healthBest)
  2069.         healthNext = healthBest;
  2070.       
  2071.       set_health_next(healthNext);
  2072.       healTimer.set();
  2073.     }
  2074.       healTimer.clock();
  2075.     }
  2076.  
  2077.   Walking::_act();
  2078.   Fighter::_act();
  2079.   Creature::act();
  2080.   User::_act();
  2081.   // NOTE: Creature::act() before User::act();
  2082. }
  2083.  
  2084.  
  2085.  
  2086. void Hero::update()
  2087. {
  2088. //  Walking::_update();
  2089.   Fighter::_update();
  2090. //  User::_update();
  2091.   Creature::update();
  2092. }
  2093.  
  2094.  
  2095.  
  2096. void Hero::die()
  2097. {
  2098.   if (!get_quiet_death())
  2099.     stats.add_death(get_birth_time());
  2100.  
  2101.   // Walking::_die();
  2102.   User::_die();
  2103.   // User::_die();
  2104.   Creature::die();
  2105. }
  2106.  
  2107.  
  2108.  
  2109. void Hero::collide(PhysicalP other) 
  2110. {
  2111.   if (!Fighter::_collide(other) && !User::_collide(other))
  2112.     Creature::collide(other);
  2113. }
  2114.  
  2115.  
  2116.  
  2117. void Hero::init_x(Xvars &xvars)
  2118. {
  2119.   Fighter::init_x(xvars);
  2120. }
  2121.  
  2122.  
  2123.  
  2124. Stats Hero::stats;
  2125.  
  2126.  
  2127.  
  2128. Ninja::Ninja(WorldP w,LocatorP l,const Pos &rawPos) 
  2129.      : Creature(creatureContext,creatureXdata,w,l,rawPos),
  2130.        Sticky(stickyContext,stickyXdata),
  2131.        Fighter(fighterContext,fighterXdata),
  2132.        User(userContext,userXdata)
  2133. {}
  2134.  
  2135.  
  2136.  
  2137. Boolean Ninja::is_fighter() 
  2138. {
  2139.   return True;
  2140. }
  2141.  
  2142.  
  2143.  
  2144. Boolean Ninja::is_sticky() 
  2145. {
  2146.   return True;
  2147. }
  2148.  
  2149.  
  2150.  
  2151. Boolean Ninja::is_user() 
  2152. {
  2153.   return True;
  2154. }
  2155.  
  2156.  
  2157.  
  2158. void Ninja::get_pixmap_mask(int dpyNum,Pixmap &pixmap,Pixmap &mask,Dir dir,int animNum)
  2159. {
  2160.   Fighter::get_pixmap_mask(dpyNum,pixmap,mask,dir,animNum);
  2161. }
  2162.  
  2163.  
  2164.  
  2165. void Ninja::get_size_offset_next(Size &size,Size &offset,Dir dirNext)
  2166. {
  2167.   Fighter::get_size_offset_next(size,offset,dirNext);
  2168. }
  2169.  
  2170.  
  2171.  
  2172. int Ninja::get_weapons_num()
  2173. {
  2174.   return User::get_weapons_num();
  2175. }
  2176.  
  2177.  
  2178.  
  2179. int Ninja::get_items_num()
  2180. {
  2181.   return User::get_items_num();
  2182. }
  2183.  
  2184.  
  2185.  
  2186. PhysicalP Ninja::get_weapon(int n)
  2187. {
  2188.   return User::get_weapon(n);
  2189. }
  2190.  
  2191.  
  2192.  
  2193. PhysicalP Ninja::get_item(int n)
  2194. {
  2195.   return User::get_item(n);
  2196. }
  2197.  
  2198.  
  2199.  
  2200.  
  2201. PhysicalP Ninja::get_weapon_current()
  2202. {
  2203.   return User::get_weapon_current();
  2204. }
  2205.  
  2206.  
  2207.  
  2208. PhysicalP Ninja::get_item_current()
  2209. {
  2210.   return User::get_item_current();
  2211. }
  2212.  
  2213.  
  2214.  
  2215. void Ninja::set_mapped_next(Boolean val)
  2216. {
  2217.  User::set_mapped_next(val);
  2218. }
  2219.  
  2220.  
  2221.  
  2222. void Ninja::act()
  2223. {
  2224.   Sticky::_act();
  2225.   Fighter::_act();
  2226.   Creature::act();
  2227.   User::_act();
  2228.   // NOTE: Creature::act() before User::act();
  2229. }
  2230.  
  2231.  
  2232.  
  2233. void Ninja::update()
  2234. {
  2235.   // Sticky::_update();
  2236.   Fighter::_update();
  2237.   // User::_update();
  2238.   Creature::update();
  2239. }
  2240.  
  2241.  
  2242.  
  2243. void Ninja::die()
  2244. {
  2245.   if (!get_quiet_death())
  2246.     stats.add_death(get_birth_time());
  2247.  
  2248.   // Sticky::_die();
  2249.   User::_die();
  2250.   // User::_die();
  2251.   Creature::die();
  2252. }
  2253.  
  2254.  
  2255.  
  2256. void Ninja::collide(PhysicalP other) 
  2257. {
  2258.   if (!Fighter::_collide(other) && !User::_collide(other))
  2259.     Creature::collide(other);
  2260. }
  2261.  
  2262.  
  2263.  
  2264. void Ninja::init_x(Xvars &xvars)
  2265. {
  2266.   Fighter::init_x(xvars);
  2267. }
  2268.  
  2269.  
  2270.  
  2271. Stats Ninja::stats;
  2272.  
  2273.  
  2274.  
  2275. Alien::Alien(WorldP w,LocatorP l,const Pos &rawPos) 
  2276.      : Creature(creatureContext,creatureXdata,w,l,rawPos),
  2277.        Sticky(stickyContext,stickyXdata)
  2278. {}
  2279.  
  2280.  
  2281.  
  2282. Boolean Alien::is_sticky()
  2283. {
  2284.   return True;
  2285. }
  2286.  
  2287.  
  2288.  
  2289. Boolean Alien::prickly()
  2290. {
  2291.   return True;
  2292. }
  2293.  
  2294.  
  2295.  
  2296. void Alien::collide(PhysicalP other)
  2297. {
  2298.   if (alive())
  2299.     other->corporeal_attack(this,ALIEN_DAMAGE);
  2300.  
  2301.   Sticky::collide(other);
  2302. }
  2303.  
  2304.  
  2305.  
  2306. void Alien::act()
  2307. {
  2308.   Sticky::act();
  2309. }
  2310.  
  2311.  
  2312.  
  2313. void Alien::die()
  2314. {
  2315.   if (!get_quiet_death())
  2316.     stats.add_death(get_birth_time());
  2317.  
  2318.   Sticky::die();
  2319. }
  2320.  
  2321.  
  2322.  
  2323. Stats Alien::stats;
  2324.  
  2325.  
  2326.  
  2327. ChopperBoy::ChopperBoy(WorldP w,LocatorP l,const Pos &rawPos) 
  2328.      : Creature(creatureContext,creatureXdata,w,l,rawPos),
  2329.        Flying(flyingContext,flyingXdata),
  2330.        User(userContext,userXdata)
  2331. {}
  2332.  
  2333.  
  2334.  
  2335. Boolean ChopperBoy::is_flying() 
  2336. {
  2337.   return True;
  2338. }
  2339.  
  2340.  
  2341.  
  2342. Boolean ChopperBoy::is_user() 
  2343. {
  2344.   return True;
  2345. }
  2346.  
  2347.  
  2348.  
  2349. int ChopperBoy::get_weapons_num()
  2350. {
  2351.   return User::get_weapons_num();
  2352. }
  2353.  
  2354.  
  2355.  
  2356. int ChopperBoy::get_items_num()
  2357. {
  2358.   return User::get_items_num();
  2359. }
  2360.  
  2361.  
  2362.  
  2363. PhysicalP ChopperBoy::get_weapon(int n)
  2364. {
  2365.   return User::get_weapon(n);
  2366. }
  2367.  
  2368.  
  2369.  
  2370. PhysicalP ChopperBoy::get_item(int n)
  2371. {
  2372.   return User::get_item(n);
  2373. }
  2374.  
  2375.  
  2376.  
  2377.  
  2378. PhysicalP ChopperBoy::get_weapon_current()
  2379. {
  2380.   return User::get_weapon_current();
  2381. }
  2382.  
  2383.  
  2384.  
  2385. PhysicalP ChopperBoy::get_item_current()
  2386. {
  2387.   return User::get_item_current();
  2388. }
  2389.  
  2390.  
  2391.  
  2392. void ChopperBoy::set_mapped_next(Boolean val)
  2393. {
  2394.  User::set_mapped_next(val);
  2395. }
  2396.  
  2397.  
  2398.  
  2399. void ChopperBoy::act()
  2400. {
  2401.   Flying::_act();
  2402.   Creature::act();
  2403.   User::_act();
  2404.   // NOTE: Creature::act() before User::act();
  2405. }
  2406.  
  2407.  
  2408.  
  2409. void ChopperBoy::update()
  2410. {
  2411.   Creature::update();
  2412. }
  2413.  
  2414.  
  2415.  
  2416. void ChopperBoy::die()
  2417. {
  2418.   if (!get_quiet_death())
  2419.     stats.add_death(get_birth_time());
  2420.  
  2421.   User::_die();
  2422.   Creature::die();
  2423. }
  2424.  
  2425.  
  2426.  
  2427. void ChopperBoy::collide(PhysicalP other) 
  2428. {
  2429.   if (!User::_collide(other))
  2430.     Creature::collide(other);
  2431. }
  2432.  
  2433.  
  2434.  
  2435. Stats ChopperBoy::stats;
  2436.  
  2437.  
  2438.  
  2439. Lemming::Lemming(WorldP w,LocatorP l,const Pos &rawPos)
  2440. : Creature(creatureContext,creatureXdata,w,l,rawPos),
  2441.   Grounded(groundedContext,groundedXdata),
  2442.   Suicide(suicideContext,suicideXdata)
  2443. {}
  2444.  
  2445.  
  2446.  
  2447. Boolean Lemming::is_suicide()
  2448. {
  2449.   return True;
  2450. }
  2451.  
  2452.  
  2453.  
  2454. void Lemming::act()
  2455. {
  2456.   Grounded::_act();
  2457.   Suicide::_act();
  2458.   Creature::act();
  2459. }
  2460.  
  2461.  
  2462.  
  2463. void Lemming::die()
  2464. {
  2465.   if (!get_quiet_death())
  2466.     stats.add_death(get_birth_time());
  2467.   
  2468.   Grounded::die();
  2469. }
  2470.  
  2471.  
  2472.  
  2473. Stats Lemming::stats;
  2474.  
  2475.  
  2476.  
  2477. FireDemon::FireDemon(WorldP w,LocatorP l,const Pos &rawPos) 
  2478.      : Creature(creatureContext,creatureXdata,w,l,rawPos),
  2479.        Flying(flyingContext,flyingXdata),
  2480.        BuiltIn(builtInContext,builtInXdata)
  2481. {
  2482.   swapResistance = FIRE_DEMON_SWAP_RESISTANCE;
  2483. }
  2484.  
  2485.  
  2486.  
  2487. Boolean FireDemon::is_flying() 
  2488. {
  2489.   return True;
  2490. }
  2491.  
  2492.  
  2493.  
  2494. Boolean FireDemon::is_built_in()
  2495. {
  2496.   return True;
  2497. }
  2498.  
  2499.  
  2500.  
  2501. Boolean FireDemon::ready()
  2502. {
  2503.   return BuiltIn::ready();
  2504. }
  2505.  
  2506.  
  2507.  
  2508. void FireDemon::heat_attack(PhysicalP,int,Boolean)
  2509. {}
  2510.  
  2511.  
  2512.  
  2513. Boolean FireDemon::swap_protect()
  2514. {
  2515.   if (swapResistance > 0)
  2516.     {
  2517.       swapResistance--;
  2518.       return True;
  2519.     }
  2520.   return False;
  2521. }
  2522.  
  2523.  
  2524.  
  2525. Boolean FireDemon::frog_protect()
  2526. {
  2527.   return True;
  2528. }
  2529.  
  2530.  
  2531.  
  2532. Size FireDemon::get_shot_size(Dir)
  2533. {
  2534.   return Fireball::get_size();
  2535. }
  2536.  
  2537.  
  2538.  
  2539. PhysicalP FireDemon::create_shot(const Pos &pos,Dir dir)
  2540. {
  2541.   PhysicalP shot = 
  2542.     new Fireball(get_world(),get_locator(),pos,get_id(),dir,
  2543.          FIRE_DEMON_FIREBALL_HEAT,FIRE_DEMON_FIREBALL_TIME);
  2544.   assert(shot);
  2545.   return shot;
  2546. }
  2547.  
  2548.  
  2549.  
  2550. void FireDemon::act()
  2551. {
  2552.   const Area &area = get_area();
  2553.   Pos pos;
  2554.   Size size;
  2555.   area.get_rect(pos,size);
  2556.   LocatorP locator = get_locator();
  2557.  
  2558.   // Generate fire.
  2559.   for (int n = 0; n < FIRE_DEMON_FIRE; n++)
  2560.     {
  2561.       Pos firePos(pos.x + Utils::choose(size.width),
  2562.           pos.y + Utils::choose((int)(.8 * size.height))); 
  2563.       
  2564.       PhysicalP fire = new Fire(get_world(),locator,firePos,False);
  2565.       locator->add(fire);
  2566.     }
  2567.  
  2568.   Flying::_act();
  2569.   BuiltIn::_act();
  2570.   Creature::act();
  2571. }
  2572.  
  2573.  
  2574.  
  2575. void FireDemon::collide(PhysicalP other)
  2576. {
  2577.   if (alive() && !other->is_shot())
  2578.     other->heat_attack(this,FIRE_DEMON_HEAT);
  2579.   
  2580.   Flying::collide(other);
  2581. }
  2582.